			//  ========== 
			//  = stack = 
			//  ========== 
			/*
			 * 创建对象         var stack = Stack.createNew();
			 * 设置labelid        stack.Labelid("a");
			 * 创建SVG            stack.CreateSvg();
			 * 绘制                   stack.Draw();
			 * 
			 * 未来：
			 *      ===;
			 * */
			! function() {
				var Stack = Object.create(Object);
				Object.defineProperties(Stack, {
					"CreateNew": {
						"value": function() {
							return FCreateNew();
						}
					}
				});

				function FCreateNew() {
					var stack = Object.create(Stack);
					//定义_labelid的属性
					stack._labelid;
					//定义设置_labelid属性的方法
					Object.defineProperties(stack, {
						"Labelid": {
							"value": function(v) {
								this._labelid = v;
								return this;
							}
						}
					});
					//定义_width的属性
					stack._width;
					//定义设置_width属性的方法
					Object.defineProperties(stack, {
						"Width": {
							"value": function(v) {
								this._width = v
								return this;
							}
						}
					});

					//定义_data的属性
					stack._data;
					//定义设置_data属性的方法
					Object.defineProperties(stack, {
						"Data": {
							"value": function(v) {
								this._data = v
								return this;
							}
						}
					});

					stack._placement_legend;
					//定义设置_width属性的方法
					Object.defineProperties(stack, {
						"Placement_legend": {
							"value": function(v) {
								this._placement_legend = v
								return this;
							}
						}
					});

					//定义_scale_type_x的属性
					stack._scale_type_x;
					//定义设置_width属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x": {
							"value": function(v) {
								this._scale_type_x = v
								return this;
							}
						}
					});

					//定义_scale_type_y的属性
					stack._scale_type_y;
					//定义设置_width属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y": {
							"value": function(v) {
								this._scale_type_y = v
								return this;
							}
						}
					});

					//定义_switch_x_transfrom的属性
					stack._switch_x_transfrom;
					//定义设置_switch_x_transfrom属性的方法
					Object.defineProperties(stack, {
						"Switch_x_transfrom": {
							"value": function(v) {
								this._switch_x_transfrom = v
								return this;
							}
						}
					});

					//定义_scale_type_x_ordinal_type的属性
					stack._scale_type_x_ordinal_type;
					//定义设置_scale_type_x_ordinal_type属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_ordinal_type": {
							"value": function(v) {
								this._scale_type_x_ordinal_type = v
								return this;
							}
						}
					});

					//定义_scale_type_x_range_type_range_array的属性
					stack._scale_type_x_range_type_range_array;
					//定义设置_scale_type_x_range_type_range_array属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_range_type_range_array": {
							"value": function(v) {
								this._scale_type_x_range_type_range_array = v
								return this;
							}
						}
					});

					//定义_scale_type_x_range_type_min的属性
					stack._scale_type_x_range_type_min;
					//定义设置_scale_type_x_range_type_min属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_range_type_min": {
							"value": function(v) {
								this._scale_type_x_range_type_min = v
								return this;
							}
						}
					});
					//定义_scale_type_x_range_type_max的属性
					stack._scale_type_x_range_type_max;
					//定义设置_scale_type_x_range_type_min属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_range_type_max": {
							"value": function(v) {
								this._scale_type_x_range_type_max = v
								return this;
							}
						}
					});

					//定义_scale_type_x_range_type_stacks_n的属性
					stack._scale_type_x_range_type_stacks_n;
					//定义设置_scale_type_x_range_type_stacks_n属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_range_type_stacks_n": {
							"value": function(v) {
								this._scale_type_x_range_type_stacks_n = v
								return this;
							}
						}
					});
					//定义_scale_type_x_range_type_Bands_p的属性
					stack._scale_type_x_range_type_Bands_p;
					//定义设置_scale_type_x_range_type_Bands_p属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_range_type_Bands_p": {
							"value": function(v) {
								this._scale_type_x_range_type_Bands_p = v
								return this;
							}
						}
					});

					//定义_scale_type_x_range_type_Bands_o的属性
					stack._scale_type_x_range_type_Bands_o;
					//定义设置_scale_type_x_range_type_Bands_o属性的方法
					Object.defineProperties(stack, {
						"Scale_type_x_range_type_Bands_o": {
							"value": function(v) {
								this._scale_type_x_range_type_Bands_o = v
								return this;
							}
						}
					});

					//定义_switch_y_transfrom的属性
					stack._switch_y_transfrom;
					//定义设置_switch_y_transfrom属性的方法
					Object.defineProperties(stack, {
						"Switch_y_transfrom": {
							"value": function(v) {
								this._switch_y_transfrom = v
								return this;
							}
						}
					});

					//定义_scale_type_y_ordinal_type的属性
					stack._scale_type_y_ordinal_type;
					//定义设置_scale_type_y_ordinal_type属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_ordinal_type": {
							"value": function(v) {
								this._scale_type_y_ordinal_type = v
								return this;
							}
						}
					});
					//定义_scale_type_y_range_type_range_array的属性
					stack._scale_type_y_range_type_range_array;
					//定义设置_scale_type_y_range_type_range_array属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_range_type_range_array": {
							"value": function(v) {
								this._scale_type_y_range_type_range_array = v
								return this;
							}
						}
					});

					//定义_scale_type_y_range_type_min的属性
					stack._scale_type_y_range_type_min;
					//定义设置_scale_type_y_range_type_min属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_range_type_min": {
							"value": function(v) {
								this._scale_type_y_range_type_min = v
								return this;
							}
						}
					});
					//定义_scale_type_y_range_type_max的属性
					stack._scale_type_y_range_type_max;
					//定义设置_scale_type_y_range_type_min属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_range_type_max": {
							"value": function(v) {
								this._scale_type_y_range_type_max = v
								return this;
							}
						}
					});

					//定义_scale_type_y_range_type_stacks_n的属性
					stack._scale_type_y_range_type_stacks_n;
					//定义设置_scale_type_y_range_type_stacks_n属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_range_type_stacks_n": {
							"value": function(v) {
								this._scale_type_y_range_type_stacks_n = v
								return this;
							}
						}
					});
					//定义_scale_type_y_range_type_Bands_p的属性
					stack._scale_type_y_range_type_Bands_p;
					//定义设置_scale_type_y_range_type_Bands_p属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_range_type_Bands_p": {
							"value": function(v) {
								this._scale_type_y_range_type_Bands_p = v
								return this;
							}
						}
					});

					//定义_scale_type_y_range_type_Bands_o的属性
					stack._scale_type_y_range_type_Bands_o;
					//定义设置_scale_type_y_range_type_Bands_o属性的方法
					Object.defineProperties(stack, {
						"Scale_type_y_range_type_Bands_o": {
							"value": function(v) {
								this._scale_type_y_range_type_Bands_o = v
								return this;
							}
						}
					});

					//定义_showbackground_x的属性
					stack._showbackground_x;
					//定义设置_showbackground_x属性的方法
					Object.defineProperties(stack, {
						"Showbackground_x": {
							"value": function(v) {
								this._showbackground_x = v
								return this;
							}
						}
					});

					//定义_showbackground_y的属性
					stack._showbackground_y;
					//定义设置_showbackground_y属性的方法
					Object.defineProperties(stack, {
						"Showbackground_y": {
							"value": function(v) {
								this._showbackground_y = v
								return this;
							}
						}
					});

					//定义_bottomAxis的属性
					stack._bottomAxis;
					//定义设置_bottomAxis属性的方法
					Object.defineProperties(stack, {
						"BottomAxis": {
							"value": function(v) {
								this._bottomAxis = v
								return this;
							}
						}
					});

					//定义_svg_type的属性
					stack._svg_type;
					//定义设置_svg_type属性的方法
					Object.defineProperties(stack, {
						"Svg_type": {
							"value": function(v) {
								this._svg_type = v
								return this;
							}
						}
					});
					
					//定义_offsetValue的属性
					stack._offsetValue;
					//定义设置_offsetValue属性的方法
					Object.defineProperties(stack, {
						"OffsetValue" : {
							"value" : function (v){
							this._offsetValue = v
							return this;
							}
						}
					});
	
					//定义_orderValue的属性
					stack._orderValue;
					//定义设置_orderValue属性的方法
					Object.defineProperties(stack, {
						"OrderValue" : {
							"value" : function (v){
							this._orderValue = v
							return this;
							}
						}
					});
//					Stack_type
					
					//定义_stack_type的属性
					stack._stack_type;
					//定义设置_stack_type属性的方法
					Object.defineProperties(stack, {
						"Stack_type" : {
							"value" : function (v){
							this._stack_type = v
							return this;
							}
						}
					});
					//定义创建svg方法
					Object.defineProperty(stack, "CreateSvg", {
						value: function() {
							CreateSvg_stack(this);
							return this;
						}
					});
					//定义设置Draw方法
					Object.defineProperty(stack, "Draw", {
						value: function() {
							draw_stack(this);
						}
					});

					CreateSvg_stack = function(stack) {
						//createSvg之前先判断stack各属性
						DetermineProperties_stack(stack);
						stack.svg = d3.selectAll("#" + stack._svgid)[0][0] == null ?
							d3.select("#" + stack._labelid)
							.append("svg")
							//                          .style("background","red")
							.attr("id", stack._svgid)
							//                          .attr("preserveAspectRatio", "xMidYMid meet")
							//                          .attr("viewBox", "0 0 " + stack._width + " " + stack._height + " ");
							.attr("width", stack._width)
							.attr("height", stack._height) : stack.svg;
						stack.tool_window = d3.select("body")
							.append("div")
							.attr({
								"class": stack._c_tool_window,
								"id": stack._id_tool_window,
								"left": 0,
								"top": stack._height,
							})
							.style({
								"opacity": 0
							})
					}
					draw_stack = function(stack) {
						Tool_stack(stack);
						DataPretreatment_stack(stack);
						d3.selectAll("." + stack._axis_x_class)[0][0] == null && stack.svg.append("g")
							.attr("class", stack._axis_x_class)
							.attr("transform", "translate(" + (stack._ToRight) + "," + (stack._height - 50 + stack._switch_x_transfrom * (stack.axis_y_scale(0))) + ")")
							.call(stack.axis_x)
							.style("font-size", "12px")
						d3.selectAll("." + stack._axis_y_class)[0][0] == null && stack.svg.append("g")
							.attr("class", stack._axis_y_class)
							.attr("transform", "translate(" + stack._ToRight + "," + (stack._height - 50) + ")")
							.call(stack.axis_y)
							.style("font-size", "12px");
						var maxlength = [];
						d3.selectAll("." + stack._axis_y_class).selectAll("text")[0].map(function(d) {
							maxlength.push(d.getComputedTextLength());
						});
						//"+(100 - 12- d3.max(maxlength)) +"
						stack.g_title_x = stack.svg.append("g")
							.attr({
								"class": stack._c_g_title_x,
								"id": stack._id_g_title_x,
								"transform": "translate(" + (stack._ToRight + stack._stack_axis_x_length / 2) + "," + (stack._height - 20) + ")"
							})
						stack.title_x_updata = stack.g_title_x.selectAll("." + stack._c_g_title_x).data(["x轴/cm"]);
						stack.title_x_enter = stack.title_x_updata.enter();
						stack.title_x_exit = stack.title_x_updata.exit();
						stack.g_title_y = stack.svg.append("g")
							.attr({
								"class": stack._c_g_grid_y_axis,
								"id": stack._id_g_grid_y_axis,
								"transform": "translate(" + (100 - 12 - d3.max(maxlength)) + " ," + (stack._height / 2) + ")"
							})
						stack.title_y_updata = stack.g_title_y.selectAll("." + stack._c_g_title_y).data(["y轴/个"]);
						stack.title_y_enter = stack.title_y_updata.enter();
						stack.title_y_exit = stack.title_y_updata.exit();

						stack.svg_legend_g = d3.selectAll("." + stack._svg_legend_g_class)[0][0] == null && stack.svg.append("g")
							.attr("class", stack._svg_legend_g_class)
							.attr("id", stack._svg_legend_g_id)
							.attr("transform", stack._placement_legend ? "translate(" + stack._width + ",0)" : "translate(0,0)");

						stack.g_grid_x_axis = stack.g_grid_x_axis || stack.svg.append("g")
							.attr({
								"class": stack._c_g_grid_x_axis,
								"id": stack._id_g_grid_x_axis,
								"transform": "translate(" + (stack._ToRight) + "," + (stack._height - 50) + ")"
							})
						stack.g_grid_y_axis = stack.g_grid_y_axis || stack.svg.append("g")
							.attr({
								"class": stack._c_g_grid_y_axis,
								"id": stack._id_g_grid_y_axis,
								"transform": "translate(" + (stack._ToRight) + "," + (stack._height - 50) + ")"
							})

						title(stack);
						grid(stack);
						legend(stack);

						function title(stack) {
							stack.title_x_enter.append("text")
								.attr({
									"class": stack._c_title_x,
									"id": stack._id_title_x,
									"x": 0,
									"dx": 0,
									"y": 0,
									"dy": 0
								})
								.style("font-size", "12px")
								.text(function(d) {
									return d;
								})
							stack.title_y_enter.append("text")
								.attr({
									"class": stack._c_title_y,
									"id": stack._id_title_y,
									"x": 0,
									"dx": 0,
									"y": 0,
									"dy": 0
								})
								.style({
									"font-size": "12px",
									"writing-mode": "tb"
								})
								.text(function(d) {
									return d;
								})

						}

						function grid(stack) {
							stack.grid_x = stack.g_grid_x_axis.call(d3.svg.axis().scale(stack.axis_x_scale).innerTickSize(-(stack._height - 100)))
							stack.grid_x.selectAll(".tick").selectAll("text").remove();
							stack.grid_x.selectAll(".domain").remove()
							stack.grid_x.selectAll("line")
								.attr("stroke-opacity", stack._showbackground_x ? 1 : 0)
								.style("stroke-dasharray", [2, 1])
							stack.grid_y = stack.g_grid_y_axis.call(d3.svg.axis().scale(stack.axis_y_scale).innerTickSize(-(stack._stack_axis_x_length)).orient("left"))
							stack.grid_y.selectAll(".tick").selectAll("text").remove();
							stack.grid_y.selectAll(".domain").remove()
							stack.grid_y.selectAll("line")
								.style("stroke-opacity", stack._showbackground_y ? 0.5 : 0)
								.style("stroke-dasharray", [2, 1])
						}
						function legend(stack) {
							stack.svg_legend_logo_updata = stack.svg_legend_g.selectAll("#" + stack._svg_legend_logo_class).data(stack._data_)
							stack.svg_legend_logo_enter = stack.svg_legend_logo_updata.enter();
							stack.svg_legend_logo_exit = stack.svg_legend_logo_updata.exit();
							stack.svg_legend_logo_enter.append("circle")
								.attr({
									"class": function(d, i) {
										return stack._svg_legend_logo_class + i;
									},
									"id": function(d, i) {
										return stack._svg_legend_logo_id + i;
									},
									"cx": function(d, i) {
										return stack._placement_legend ? (-10) : 110 + i * ((stack._width - 100) / stack._data_.length);

									},
									"cy": function(d, i) {
										return stack._placement_legend ? (20 * i + 10) : 10;
									},
									"fill": function(d, i) {
										return stack._scalecolor(d.name);
									},
									"r": function(d, i) {
										return "5px";

									}
								});

							stack.svg_legend_text_updata = stack.svg_legend_g.selectAll("#" + stack._svg_legend_text_class).data(stack._data_)
							stack.svg_legend_text_enter = stack.svg_legend_text_updata.enter();
							stack.svg_legend_text_exit = stack.svg_legend_text_updata.exit();
							stack.svg_legend_text_enter.append("text")
								.attr({
									"class": function(d, i) {
										return stack._svg_legend_text_class + i;
									},
									"id": function(d, i) {
										return stack._svg_legend_text_id + i;
									},
									"x": function(d, i) {
										return stack._placement_legend ? -(10 + 5) : 115 + i * ((stack._width - 100) / stack._data_.length);

									},
									"y": function(d, i) {
											return stack._placement_legend ? (20 * i + 10 + 5) : 10 + 5;
										} //,

									//									"r": function(d, i) {
									//										return "5px";
									//
									//									}
								})
								.text(function(d, i) {
									return d.name
								})
								.style("text-anchor", stack._placement_legend ? "end" : "start")
						}

						var type = ["area", "rect"];
						console.log(type.indexOf(stack._stack_type));
						type.indexOf(stack._stack_type) == 0 ? a(stack) : b(stack);

						function a(stack) {
							var area = d3.svg.area()
//								.interpolate("cardinal")
								.interpolate("line")
								.x(function(d) {
									console.log("X------",d,stack.axis_x_scale(d.x));
									return stack.axis_x_scale(d[0]);
								})
								.y0(function(d) {
									console.log("y0:" + d.y0 + d.y);
									return stack._height - 50 + stack.axis_y_scale(d.y0 + d.y);
								})
								.y1(function(d) {
									console.log("y1:" + d.y0);
									return stack._height - 50 + stack.axis_y_scale(d.y0);
								});
							stack.svg.selectAll("." + stack._stack_class)
								.data(stack._data_)
								.enter().append("path")
								.attr("class", stack._stack_class)
								.attr("d", function(d) {
									console.log("DDDD",d);
									return area(d);
								})
								.style("fill", function(d, i) {
									return stack._scalecolor(i);
								})
								.attr("transform", "translate(" + stack._ToRight + "," + 0 + ")")
						}

						function b(stack) {
							stack.svg.selectAll("." + stack._stack_class)
								.data(stack._layoutStack(stack._data_))
								.enter().append("g")
								.attr("class", stack._stack_class)
								.style("fill", function(d, i) {
									return stack._scalecolor(d.name);
								})
								.selectAll("rect")
								.data(function(d) {
									return d;
								})
								.enter()
								.append("rect")
								.attr({
									x: function(d, i) {
										return stack.axis_x_scale(d[0]);
									},
									y: function(d) {
										return stack.axis_y_scale(d.y0 + d.y);
									},
									height: function(d) {

										return Math.abs(stack.axis_y_scale(d.y));
									},
									width: 30
								})

							.attr("transform", "translate(" + stack._ToRight + "," + (stack._height - 50) + ")")

						}

						
					}
					Tool_stack = function(stack) {
						stack._scalecolor = d3.scale.category10();
						
						stack._layoutStack = d3.layout.stack()
							.x(function(d) {
								return Number(d[0]);
							})
							.y(function (d) {
							    return Number(d[1]);
							});
						stack._offsetValue == 0 ? stack._layoutStack :
							(stack._offsetValue == 1 ? stack._layoutStack.offset("silhouette ") :
								(stack._offsetValue == 2 ? stack._layoutStack.offset("wiggle ") :
									(stack._offsetValue == 3 ? stack._layoutStack.offset("expand") : stack._layoutStack.offset("zero"))))
						stack._orderValue == 0 ? stack._layoutStack : (
								(stack._orderValue == 1 ? stack._layoutStack.order("default ") :
									(stack._orderValue == 2 ? stack._layoutStack.order("reverse  ") : stack._layoutStack.order("inside-out"))))
							//  						
					}

					DataPretreatment_stack = function(stack) {

						stack._data_ = [];
					stack._data_.columns = [];
						stack._data.map(function(d, i) { // >0则开始得出数据
							i == 0 ? (d.map(function(d, i) {
									// >0则开始得出数据
									i == 0 ? "" : stack._data_.columns.push(d);
								})) :
								( // >0则开始得出数据33
									name, stack._data_[i - 1] = [],
									d.map(function(d, j) {
										j == 0 ? name = d : (a = [stack._data_.columns[j - 1], d], a.name = stack._data_[i - 1].name = name, a.i = i, stack._data_[i - 1].push(a))
									}))
						})
						stack._layoutStack(stack._data_)
						stack._scalecolor();
						Package_scale(stack, "x");
						Package_scale(stack, "y");
						//						Package_stack(stack);
					}
					Package_stack = function(stack) {

					}
					Package_scale = function(stack, object) {
						var scale;
						var array = ["_scale_type_" + object, //0
							"_scale_type_" + object + "_ordinal_type", //1
							"_scale_type_" + object + "_range_type_range_array", //2
							"_scale_type_" + object + "_range_type_min", //3
							"_scale_type_" + object + "_range_type_max", //4
							"_scale_type_" + object + "_range_type_Points_n", //5
							"_scale_type_" + object + "_range_type_Bands_p", //6
							"_scale_type_" + object + "_range_type_Bands_o", //7
							"_axis_" + object + "_data", //8
							"axis_" + object + "_scale", //9
							"axis_" + object, //10
							"_showbackground_" + object //11
						];

						if(stack[array[0]] == 1) {
							scale = d3.scale.linear();
							var max = [],
								min = [];

							stack._data_.map(function(d) {
								max.push(d3.max(d.map(function(d) {
									var a = d[object == stack._bottomAxis ? 0 : "y0"];
									return typeof(a) == "string" ? Number(a) : a;
								})))
								min.push(d3.min(d.map(function(d) {
									var a = d[object == stack._bottomAxis ? 0 : 1];
									return typeof(a) == "string" ? Number(a) : a;
								})))
							})
							var domain = [d3.min(min), d3.max(max)]
								//							stack[array[8]] = Filterthedata(stack._data, "data") /*[0].stacks*/ .map(function(d, i) {
								//
								//								return d[0][(object == "x" ? "x" : "value1")];
								//							}).sort(function(a, b) {
								//								return b - a;
								//							})
							var ceshi = domain.map(function(d, i) {
								if(i == 0) {
									var ii = 0;

									var f = d >= 0 ? 1 : -1;
									var num = Math.abs(d);
									while(num >= 10) {
										num = (num - (num % 10)) / 10;
										ii++;
									}
									var c = Math.pow(10, ii)
									var o = Math.ceil(Math.abs(d) / c)
									var shu = f > 0 ? (c == 1 ? 0 : f * o * c) : (c == 1 ? 10 * f : f * o * c);
									return shu;
								} else {
									//  ========== 
									//  = 此处不该纠结 = 
									//  ========== 
									var ii = 0;

									var f = d >= 0 ? 1 : -1;
									var num = Math.abs(d);
									while(num >= 10) {
										num = (num - (num % 10)) / 10;
										ii++;
									}
									var c = Math.pow(10, ii)
									var o = Math.ceil(Math.abs(d) / c)
									var shu = f > 0 ? (c == 1 ? 10 * f : f * o * c) : (c == 1 ? 0 : f * o * c);
									return shu;
								}
							});
							scale.domain(ceshi); //数值中的元素依旧是数组。但是实际需要时每个元素的第一个值来衡量。stack._data，function(d){return d[1]};设置无效。
							//							var max = d3.max(stack._layoutstack(stack._data), function(d) {
							//								return d3.max(d.values, function(d) {
							//									return d.y0 + d.y;
							//								});
							//							})
							//							object == "y" && scale.domain([0, max]);
							scale.rangeRound([(object == "x" ? 1 : -1) * stack[array[3]], (object == "x" ? 1 : -1) * stack[array[4]]])

						} else if(stack[array[0]] == 2) {
							scale = d3.scale.ordinal();
							stack[array[8]] = stack._data_.columns
								/*.sort(function(a, b) {
								                            return a - b
								                        })*/
							if(stack[array[1]] == 1) {
								scale.range(stack[array[2]]);
							} else if(stack[array[1]] == 2) {
								scale.rangeRoundPoints([(object == "x" ? 1 : -1) * stack[array[3]], (object == "x" ? 1 : -1) * stack[array[4]]], stack[array[5]]);
							} else {
								scale.rangeRoundBands([(object == "x" ? 1 : -1) * stack[array[3]], (object == "x" ? 1 : -1) * stack[array[4]]], stack[array[6]], stack[array[7]])
							}
							scale.domain(stack[array[8]]); //数值中的元素依旧是数组。但是实际需要时每个元素的第一个值来衡量。stack._data，function(d){return d[1]};设置无效。
						} else {
							scale = d3.time.scale();
						}

						stack[array[9]] = scale;
						stack[array[10]] = d3.svg.axis()
							.scale(stack[array[9]])
							.tickSize(1)
							//                              .innerTickSize(object == "x" ? -3 : 3)
							.innerTickSize(3)
							//							.outerTickSize(object == "x" ? (stack[array[11]] == true ?  stack._switch_x_transfrom * stack.axis_x_scale(0) -19 : 0) : (stack[array[11]] == true ? - stack._switch_y_transfrom * stack.axis_y_scale(0) +19 : 0))
							.orient(object == "x" ? "bottom" : "left");
					}

					function Filterthedata(array, str) {
						var a = str.split("-");
						a.map(function(d, i) {
							array = array[d];
						})
						return array;
					}

					//  ========== 
					//  = 判断属性 = 
					//  ========== 
					Detect_function_stack = function(object_lh) {
						return typeof(object_lh) == "undefined";
					}
					DetermineProperties_stack = function(stack) {
						SetId_stack(stack);
						stack._height = stack._width < 300 ? alert("width不能< 300") :
							(stack._width / 0.618 * (1 - 0.618) < 500 ? stack._width / 0.618 * (1 - 0.618) : 500);
						stack._ToRight = 100;
						stack._legend_length = 100;
						stack._stack_axis_x_length = stack._width - stack._ToRight - (stack._placement_legend ? stack._legend_length : 30);
						stack._scale_type_x_range_type_min = 0;
						stack._scale_type_x_range_type_max = stack._stack_axis_x_length;
						stack._scale_type_y_range_type_min = 0;
						stack._scale_type_y_range_type_max = stack._height - 100;

					}
					SetId_stack = function(stack) {
						stack._svgid = stack._labelid + "svg";
						stack._axis_x_class = stack._labelid + "axis_x_class";
						stack._axis_y_class = stack._labelid + "axis_y_class";

						stack._c_g_title_x = stack._labelid + "_c_g_title_x"
						stack._id_g_title_x = stack._labelid + "_id_g_title_x"
						stack._c_title_x = stack._labelid + "_c_title_x"
						stack._id_title_x = stack._labelid + "_id_title_x"

						stack._c_g_title_y = stack._labelid + "_c_g_title_y"
						stack._id_g_title_y = stack._labelid + "_id_g_title_y"
						stack._c_title_y = stack._labelid + "_c_title_y"
						stack._id_title_y = stack._labelid + "_id_title_y"

						stack._c_g_grid_x_axis = stack._labelid + "_c_g_grid_x_axis";
						stack._id_g_grid_x_axis = stack._labelid + "_id_g_grid_x_axis";
						stack._c_g_grid_y_axis = stack._labelid + "_c_g_grid_y_axis";
						stack._id_g_grid_y_axis = stack._labelid + "_id_g_grid_y_axis";
						stack._c_grid_x_axis = stack._labelid + "_c_grid_x_axis";
						stack._id_grid_x_axis = stack._labelid + "_id_grid_x_axis";
						stack._c_grid_y_axis = stack._labelid + "_c_grid_y_axis";
						stack._id_grid_y_axis = stack._labelid + "_id_grid_y_axis";
						stack._svg_legend_g_class = stack._labelid + "legend_g_class";
						stack._svg_legend_g_id = stack._labelid + "legend_g_id";
						stack._svg_legend_logo_class = stack._labelid + "legend_logo_class";
						stack._svg_legend_logo_id = stack._labelid + "legend_logo_id";
						stack._svg_legend_text_class = stack._labelid + "legend_text_class";
						stack._svg_legend_text_id = stack._labelid + "legend_text_id";
						stack._stack_id = stack._labelid + "stack_id";
						stack._stack_class = stack._labelid + "stack_class";
						
						stack._c_tool_g = stack._labelid + "_c_tool_g";
						stack._id_tool_g = stack._labelid + "_id_tool_g";
						stack._c_tool_line = stack._labelid + "_c_tool_line";
						stack._id_tool_line = stack._labelid + "_id_tool_line";
						stack._c_tool_window = "Tooltip";
						stack._id_tool_window = stack._labelid + "Tooltip_id";

					}
					return stack;
				};
				this.Stack = Stack;
			}();